App({
  onLaunch: function() {// 初始化云环境(小程序启动时的初始化)
    if (!wx.cloud) {
      console.error('请使用 2.2.3 或以上的基础库以使用云能力');
    } else {
        wx.cloud.init({
        env: 'cloud1-5gg437qe344eb170',  // 确保环境 ID 正确
        traceUser: true
      });
    }

    
    // 展示本地存储能力（可选）
    const logs = wx.getStorageSync('logs') || [];
    logs.unshift(Date.now());
    wx.setStorageSync('logs', logs);

    // 移除不存在的 wx.onLocalStorageChange 方法
    // 改为检查登录状态
    this.checkLoginStatus();
    
    // 启动提醒检查
    this.startReminderCheck();
    
    // 登录
    wx.login({
      success: res => {  // ✅ 修正语法错误
        // 发送 res.code 到后台换取 openId
      }
    });
  },

 
   
   // 检查提醒 - 改进版（考虑周）
checkReminders: async function() {
  console.info('[提醒系统] 开始检查提醒');
  
  try {
    const db = this.getDB();
    const now = new Date();
    
    // 添加更详细的日志
    console.info(`[提醒系统] 当前时间: ${now.toLocaleString()}`);
    
    // 查询需要触发的提醒：状态为pending且提醒时间已到但不超过课程开始时间
    const { data } = await db.collection('reminders').where({
      status: 'pending',
      reminderDateTime: db.command.lte(now)
    }).get();
    
    console.info(`[提醒系统] 找到 ${data.length} 条需要处理的提醒`);
    
    // 如果没有找到提醒，检查是否有缺少reminderDateTime的记录
    if (data.length === 0) {
      const missingDateTimeReminders = await db.collection('reminders').where({
        status: 'pending',
        reminderDateTime: db.command.exists(false)
      }).count();
      
      console.info(`[提醒系统] 发现 ${missingDateTimeReminders.total} 条缺少reminderDateTime的提醒记录`);
      
      // 如果有测试模式，创建一个测试提醒
      if (this.globalData.autoCreateTestReminder) {
        await this.createTestReminder();
      }
    }
    
    // 处理每条提醒
    for (const reminder of data) {
      console.info(`[提醒系统] 处理提醒: ${reminder._id}, 提醒时间: ${reminder.reminderDateTime ? new Date(reminder.reminderDateTime).toLocaleString() : '未设置'}`);
      
      // 检查课程是否已经开始超过5分钟
      const courseStartTime = this.parseTimeToMinutes(reminder.startTime);
      const currentTime = now.getHours() * 60 + now.getMinutes();
      
      console.info(`[提醒系统] 课程开始时间: ${reminder.startTime} (${courseStartTime}分钟), 当前时间: ${now.getHours()}:${now.getMinutes()} (${currentTime}分钟)`);
      
      if (currentTime > courseStartTime + 5) {
        // 课程已经开始超过5分钟，标记为过期
        await db.collection('reminders').doc(reminder._id).update({
          data: {
            status: 'expired',
            processTime: db.serverDate()
          }
        });
        console.info(`[提醒系统] 提醒已过期: ${reminder.courseName}`);
      } else {
        // 处理提醒
        await this.processReminder(reminder);
      }
    }
    
  } catch (err) {
    console.error('[提醒系统] 检查提醒失败:', err);
  }
},
  
  // 处理提醒
  processReminder: async function(reminder) {
    console.info('[提醒系统] 处理提醒:', reminder._id, reminder.courseName);
    
    try {
      const db = this.getDB();
      
      // 更新提醒状态为已处理
      await db.collection('reminders').doc(reminder._id).update({
        data: {
          status: 'processed',
          processTime: db.serverDate()
        }
      });
      
      // 如果不是测试提醒且有周期性属性，创建下一周的提醒
      if (!reminder.isTestReminder && reminder.weekday !== undefined) {
        await this.createNextWeekReminder(reminder);
      }
      
      // 如果小程序在前台，直接显示提醒
      const pages = getCurrentPages();
      if (pages.length > 0) {
        const currentPage = pages[pages.length - 1];
        if (typeof currentPage.showLocalNotification === 'function') {
          currentPage.showLocalNotification(reminder);
        } else {
          // 如果当前页面没有显示通知的方法，使用全局方法
          this.showGlobalNotification(reminder);
        }
      } else {
        // 如果没有页面实例，使用全局方法
        this.showGlobalNotification(reminder);
      }
      
    } catch (err) {
      console.error('[提醒系统] 处理提醒失败:', err);
    }
  },
    // 在课程更新时同步更新相关提醒
    syncCourseReminders: async function(courseId, courseData) {
      console.info(`[提醒系统] 开始同步课程提醒: ${courseId}`);
      
      try {
        const db = this.getDB();
        
        // 查询与该课程相关的所有待处理提醒
        const { data } = await db.collection('reminders').where({
          courseId: courseId,
          status: 'pending'
        }).get();
        
        console.info(`[提醒系统] 找到 ${data.length} 条需要同步的提醒`);
        
        // 如果课程被删除，取消所有相关提醒
        if (!courseData) {
          for (const reminder of data) {
            await db.collection('reminders').doc(reminder._id).update({
              data: {
                status: 'cancelled',
                cancelReason: '课程已删除',
                updateTime: db.serverDate()
              }
            });
          }
          console.info(`[提醒系统] 已取消 ${data.length} 条提醒，原因: 课程已删除`);
          return;
        }
        
        // 更新每条提醒的课程信息
        for (const reminder of data) {
          // 计算新的提醒时间
          const reminderMinutes = this.parseReminderTime(reminder.reminderTime || '提前5分钟');
          const [hours, minutes] = courseData.startTime.split(':').map(Number);
          
          // 保持原提醒的日期部分，只更新时间部分
          const originalDate = new Date(reminder.reminderDateTime);
          originalDate.setHours(hours);
          originalDate.setMinutes(minutes - reminderMinutes);
          originalDate.setSeconds(0);
          
          // 更新提醒记录
          await db.collection('reminders').doc(reminder._id).update({
            data: {
              courseName: courseData.courseName,
              startTime: courseData.startTime,
              classroom: courseData.classroom,
              weekday: parseInt(courseData.weekday),
              weekdayName: ['周日','周一','周二','周三','周四','周五','周六'][parseInt(courseData.weekday)],
              timeSlot: parseInt(courseData.timeSlot),
              reminderDateTime: originalDate,
              updateTime: db.serverDate()
            }
          });
          
          console.info(`[提醒系统] 已更新提醒: ${reminder._id}`);
        }
        
        console.info(`[提醒系统] 课程提醒同步完成: ${courseId}`);
        
      } catch (err) {
        console.error(`[提醒系统] 同步课程提醒失败: ${courseId}`, err);
      }
    },
    
    // 在课程删除时取消相关提醒
    cancelCourseReminders: async function(courseId) {
      console.info(`[提醒系统] 开始取消课程提醒: ${courseId}`);
      
      try {
        const db = this.getDB();
        
        // 查询与该课程相关的所有待处理提醒
        const { data } = await db.collection('reminders').where({
          courseId: courseId,
          status: 'pending'
        }).get();
        
        console.info(`[提醒系统] 找到 ${data.length} 条需要取消的提醒`);
        
        // 取消所有相关提醒
        for (const reminder of data) {
          await db.collection('reminders').doc(reminder._id).update({
            data: {
              status: 'cancelled',
              cancelReason: '课程已删除',
              updateTime: db.serverDate()
            }
          });
        }
        
        console.info(`[提醒系统] 已取消 ${data.length} 条提醒，原因: 课程已删除`);
        
      } catch (err) {
        console.error(`[提醒系统] 取消课程提醒失败: ${courseId}`, err);
      }
    },
  // 创建下一周的提醒
  createNextWeekReminder: async function(reminder) {
    try {
      const db = this.getDB();
      
      // 计算下一周的提醒时间
      const nextReminderDate = new Date();
      
      // 设置为下周的同一天
      nextReminderDate.setDate(nextReminderDate.getDate() + 7);
      
      // 设置小时和分钟（从原提醒中获取）
      const reminderMinutes = this.parseReminderTime(reminder.reminderTime || '提前5分钟');
      const [hours, minutes] = reminder.startTime.split(':').map(Number);
      nextReminderDate.setHours(hours);
      nextReminderDate.setMinutes(minutes - reminderMinutes);
      nextReminderDate.setSeconds(0);
      
      console.info(`[提醒系统] 创建下一周提醒: ${reminder.courseName}, 时间: ${nextReminderDate.toLocaleString()}`);
      
      // 创建新的提醒记录
      await db.collection('reminders').add({
        data: {
          courseId: reminder.courseId,
          courseName: reminder.courseName,
          startTime: reminder.startTime,
          classroom: reminder.classroom,
          weekday: reminder.weekday,
          weekdayName: reminder.weekdayName,
          timeSlot: reminder.timeSlot,
          reminderTime: reminder.reminderTime,
          reminderContent: reminder.reminderContent,
          teacherId: reminder.teacherId,
          reminderDateTime: nextReminderDate,
          createTime: db.serverDate(),
          status: 'pending',
          useLocalNotification: reminder.useLocalNotification || true,
          isRecurring: true, // 标记为周期性提醒
          parentReminderId: reminder._id // 记录原始提醒ID
        }
      });
      
      console.info(`[提醒系统] 已创建下一周提醒: ${reminder.courseName}`);
      
    } catch (err) {
      console.error('[提醒系统] 创建下一周提醒失败:', err);
    }
  },
  
  // 解析提醒时间字符串为分钟数
  parseReminderTime: function(reminderTimeStr) {
    const match = reminderTimeStr.match(/提前(\d+)分钟/);
    if (match && match[1]) {
      return parseInt(match[1]);
    }
    return 5; // 默认提前5分钟
  },
  // 将时间字符串转换为分钟数
  parseTimeToMinutes: function(timeStr) {
    const [hours, minutes] = timeStr.split(':').map(Number);
    return hours * 60 + minutes;
  },
  
  
  
  // 全局显示通知
  showGlobalNotification: function(reminder) {
    wx.showModal({
      title: '课程提醒',
      content: `${reminder.courseName}\n时间: ${reminder.startTime}\n地点: ${reminder.classroom}\n${reminder.reminderContent || '即将开始，请做好准备'}`,
      showCancel: false,
      confirmText: '我知道了'
    });
    
    // 播放提示音
    const innerAudioContext = wx.createInnerAudioContext();
    innerAudioContext.src = '/assets/sounds/notification.mp3';
    innerAudioContext.play();
  },
  
  // 在 onLaunch 或 onShow 中启动定时检查
  onShow: function() {
    // 每分钟检查一次提醒
    this.startReminderCheck();
  },
  
  // 启动提醒检查
  startReminderCheck: function() {
    // 清除之前的定时器
    if (this.reminderCheckTimer) {
      clearInterval(this.reminderCheckTimer);
    }
    
    // 设置新的定时器，每分钟检查一次
    this.reminderCheckTimer = setInterval(() => {
      this.checkReminders();
    }, 60000); // 60秒
    
    // 立即执行一次检查
    this.checkReminders();
  },
    
    // 创建测试提醒
    createTestReminder: async function() {
      try {
        const db = this.getDB();
        const teacherId = wx.getStorageSync('teacherId');
        
        // 创建一个2分钟后触发的测试提醒
        const now = new Date();
        const reminderTime = new Date(now.getTime() + 2 * 60 * 1000); // 2分钟后
        
        // 检查是否已存在测试提醒
        const existingTest = await db.collection('reminders')
          .where({
            teacherId: teacherId,
            isTestReminder: true
          })
          .get();
        
        // 如果已存在测试提醒，则更新它
        if (existingTest.data.length > 0) {
          await db.collection('reminders')
            .doc(existingTest.data[0]._id)
            .update({
              data: {
                reminderDateTime: reminderTime,
                status: 'pending',
                updateTime: db.serverDate()
              }
            });
          console.info('[提醒系统] 更新了现有测试提醒:', existingTest.data[0]._id);
          return existingTest.data[0]._id;
        }
        
        // 否则创建新的测试提醒
        const result = await db.collection('reminders').add({
          data: {
            courseId: 'test_course_id',
            courseName: '测试课程',
            startTime: now.getHours() + ':' + now.getMinutes(),
            classroom: '测试教室',
            weekday: now.getDay(),
            weekdayName: ['周日','周一','周二','周三','周四','周五','周六'][now.getDay()],
            timeSlot: 0,
            reminderTime: '提前5分钟',
            reminderContent: '这是一条测试提醒',
            teacherId: teacherId,
            reminderDateTime: reminderTime,
            createTime: db.serverDate(),
            status: 'pending',
            isTestReminder: true
          }
        });
        
        console.info('[提醒系统] 创建了新的测试提醒:', result._id);
        return result._id;
      } catch (err) {
        console.error('[提醒系统] 创建测试提醒失败:', err);
        return null;
      }
    },
  
  // 发送提醒
  sendReminder: async function(reminder) {
    console.info('[提醒系统] 处理提醒:', reminder._id, reminder.courseName);
    
    try {
      const db = this.getDB();
      
      // 请求订阅消息权限
      const tmplId = this.globalData.subscribeTemplateId;
      const subscribeRes = await wx.requestSubscribeMessage({
        tmplIds: [tmplId]
      });
      
      console.info('[提醒系统] 订阅结果:', subscribeRes);
      
      if (subscribeRes[tmplId] === 'accept') {
        // 用户接受了订阅，发送消息
        console.info('[提醒系统] 用户接受了订阅，准备发送消息');
        
        // 构建消息数据
        const msgData = {
          thing1: { value: reminder.courseName }, // 课程名称
          thing2: { value: reminder.classroom },  // 教室
          time3: { value: reminder.startTime },   // 上课时间
          thing4: { value: `${reminder.weekdayName || ''}第${(reminder.timeSlot || 0)+1}节` } // 课程信息
        };
        
        console.info('[提醒系统] 消息数据:', msgData);
        
        // 更新提醒状态为已发送
        await db.collection('reminders').doc(reminder._id).update({
          data: {
            status: 'sent',
            sendTime: db.serverDate(),
            sendResult: {
              accepted: true,
              data: msgData
            }
          }
        });
        
        console.info('[提醒系统] 提醒已标记为已发送:', reminder._id);
        
        // 显示本地通知
        wx.showToast({
          title: `${reminder.courseName}即将开始`,
          icon: 'none',
          duration: 3000
        });
      } else {
        // 用户拒绝了订阅
        console.warn('[提醒系统] 用户拒绝了订阅');
        
        // 更新提醒状态
        await db.collection('reminders').doc(reminder._id).update({
          data: {
            status: 'rejected',
            rejectTime: db.serverDate()
          }
        });
      }
    } catch (err) {
      console.error('[提醒系统] 发送提醒失败:', err);
      
      // 更新提醒状态为失败
      const db = this.getDB();
      await db.collection('reminders').doc(reminder._id).update({
        data: {
          status: 'failed',
          lastError: err.message || JSON.stringify(err),
          errorTime: db.serverDate(),
          retryCount: db.command.inc(1)
        }
      });
    }
  },
  // 调试提醒系统
  debugReminderSystem: async function() {
    console.info('[调试] 开始调试提醒系统');
    
    // 启用自动创建测试提醒
    this.globalData.autoCreateTestReminder = true;
    
    // 检查提醒
    await this.checkReminders();
    
    // 恢复设置
    this.globalData.autoCreateTestReminder = false;
    
    console.info('[调试] 提醒系统调试完成');
  },
  // 检查登录状态
  checkLoginStatus() {
    const teacherId = wx.getStorageSync('teacherId');
    if (!teacherId) {
      wx.reLaunch({ url: '/pages/profile/profile' });
    }
  },
 // 自定义存储方法，可以在设置存储时触发回调
 setStorageWithCallback(key, data, callback) {
  wx.setStorage({
    key: key,
    data: data,
    success: () => {
      if (typeof callback === 'function') {
        callback(key, data);
      }
      // 特殊处理 teacherId
      if (key === 'teacherId' && !data) {
        wx.reLaunch({ url: '/pages/profile/profile' });
      }
    }
  });
},

  // 获取数据库实例
  getDB() {
    if (!this.globalData.cloudDB) {
      this.globalData.cloudDB = wx.cloud.database();  // ✅ 无需重复指定环境
    }
    return this.globalData.cloudDB;
  },
  
  // 应用退出时清理
  onHide: function() {
    // 清除定时器
    if (this.reminderTimer) {
      clearInterval(this.reminderTimer);
    }
  },
  // 在 app.js 中添加调试提醒系统的函数
  
  // 调试提醒系统
  debugReminderSystem: async function() {
    console.info('[调试] 开始调试提醒系统');
    
    // 启用自动创建测试提醒
    this.globalData.autoCreateTestReminder = true;
    
    // 检查提醒
    await this.checkReminders();
    
    // 恢复设置
    this.globalData.autoCreateTestReminder = false;
    
    console.info('[调试] 提醒系统调试完成');
  },
  globalData: {
    userInfo: null,
    cloudDB: null, // ✅ 统一在此处声明
    subscribeTemplateId: 'FjvVLdPWxHONyFtFa5cqCknQX8Lex-R0cqVyGnSDHUY' ,// 课程提醒订阅消息模板ID
    autoCreateTestReminder: false // 是否自动创建测试提醒
  }
  
});


// ✅ 添加全局应用实例引用
// const app = getApp();